package com.fileupload.process;

import com.fileupload.common.FileUtils;
import com.fileupload.process.strategy.FileFinishActionStrategyFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 * 文件处理服务实现类
 * @author 小乙
 */
@Service
public class FileProcessServiceImpl implements FileProcessService {
    
    private static final Logger logger = LoggerFactory.getLogger(FileProcessServiceImpl.class);
    
    @Autowired
    private FileFinishActionStrategyFactory strategyFactory;

    @Override
    public boolean processFile(File file, String action, String moveToPath, String monitorDir) {
        logger.info("[文件处理进程] 开始执行文件处理操作");
        
        if (file == null || !file.exists()) {
            logger.warn("[文件处理进程] 要处理的文件不存在: {}", file);
            return false;
        }
        
        if (action == null || action.isEmpty()) {
            logger.warn("[文件处理进程] 处理动作不能为空");
            return false;
        }
        
        logger.info("[文件处理进程] 处理参数 - 文件: {}, 动作: {}, 目标路径: {}, 监控目录: {}", 
                file.getAbsolutePath(), action, moveToPath != null ? moveToPath : "未指定", monitorDir);
        
        try {
            // 通过策略工厂获取对应的文件操作策略
            logger.info("[文件处理进程] 获取文件操作策略: {}", action);
            boolean result = strategyFactory.getStrategy(action, monitorDir).execute(file, moveToPath);
            
            if (result) {
                logger.info("[文件处理进程] 文件处理成功 - 动作: '{}', 文件: {}, 目标路径: {}", 
                        action, file.getAbsolutePath(), moveToPath != null ? moveToPath : "未指定");
            } else {
                logger.error("[文件处理进程] 文件处理失败 - 动作: '{}', 文件: {}, 目标路径: {}", 
                        action, file.getAbsolutePath(), moveToPath != null ? moveToPath : "未指定");
            }
            
            logger.info("[文件处理进程] 文件处理操作完成 - 结果: {}", result ? "成功" : "失败");
            return result;
        } catch (Exception e) {
            logger.error("[文件处理进程] 处理文件异常 - 文件: {}, 动作: {}, 异常: {}", 
                    file.getAbsolutePath(), action, e.getMessage(), e);
            return false;
        }
    }
    
    @Override
    public boolean processFileWithMultipleActions(File file, String actions, String moveToPath, String monitorDir) {
        logger.debug("Processing file with multiple actions: {}, actions: {}, monitorDir: {}", 
                   file.getAbsolutePath(), actions, monitorDir);
        
        if (file == null || !file.exists()) {
            logger.error("File does not exist: {}", file);
            return false;
        }
        
        if (actions == null || actions.trim().isEmpty()) {
            logger.warn("No actions specified for file: {}", file.getAbsolutePath());
            return true;
        }
        
        // 分割多个操作
        String[] actionArray = actions.split("/");
        
        boolean allSuccess = true;
        
        for (String action : actionArray) {
            String trimmedAction = action.trim();
            if (trimmedAction.isEmpty()) {
                continue;
            }
            
            try {
                boolean result = strategyFactory.getStrategy(trimmedAction, monitorDir).execute(file, moveToPath);
                
                if (result) {
                    logger.info("执行动作成功: '{}', 文件: {}", trimmedAction, file.getAbsolutePath());
                } else {
                    logger.error("执行动作失败: '{}', 文件: {}", trimmedAction, file.getAbsolutePath());
                    allSuccess = false;
                    // 失败时继续执行下一个动作，可以根据业务需求决定是否中断
                }
            } catch (Exception e) {
                logger.error("执行动作异常: '{}', 文件: {}, 异常: {}", 
                           trimmedAction, file.getAbsolutePath(), e.getMessage(), e);
                allSuccess = false;
            }
            
            // 检查文件是否还存在（例如前一个动作可能是删除）
            if (!file.exists()) {
                logger.debug("文件不存在，停止后续动作执行: {}", file.getAbsolutePath());
                break;
            }
        }
        
        return allSuccess;
    }
    

    
    @Override
    public boolean moveFile(File file, String targetPath) {
        if (file == null || !file.exists()) {
            logger.warn("要移动的文件不存在: {}", file);
            return false;
        }
        
        if (targetPath == null || targetPath.isEmpty()) {
            logger.warn("目标路径不能为空");
            return false;
        }
        
        try {
            File targetFile;
            // 确保目标目录存在
            if (targetPath.endsWith("/")) {
                targetFile = new File(targetPath, file.getName());
                // 如果目标文件已存在，先删除
                if (targetFile.exists()) {
                    logger.info("目标文件已存在，尝试删除: {}", targetFile.getAbsolutePath());
                    if (!targetFile.delete()) {
                        logger.warn("无法删除已存在的目标文件: {}", targetFile.getAbsolutePath());
                    }
                }
                return file.renameTo(targetFile);
            } else {
                // 目标路径包含文件名
                targetFile = new File(targetPath);
                Path targetDirPath = targetFile.toPath().getParent();
                if (targetDirPath != null) {
                    FileUtils.ensureDirectoryExists(targetDirPath);
                }
                // 如果目标文件已存在，先删除
                if (targetFile.exists()) {
                    logger.info("目标文件已存在，尝试删除: {}", targetFile.getAbsolutePath());
                    if (!targetFile.delete()) {
                        logger.warn("无法删除已存在的目标文件: {}", targetFile.getAbsolutePath());
                    }
                }
                return file.renameTo(targetFile);
            }
        } catch (Exception e) {
            logger.error("移动文件异常: {}, 文件: {}, 目标路径: {}", 
                    e.getMessage(), file.getAbsolutePath(), targetPath, e);
            return false;
        }
    }
    
    @Override
    public boolean deleteFile(File file) {
        if (file == null || !file.exists()) {
            logger.warn("要删除的文件不存在: {}", file);
            return false;
        }
        
        try {
            boolean result = file.delete();
            if (result) {
                logger.info("文件删除成功: {}", file.getAbsolutePath());
            } else {
                logger.error("文件删除失败: {}", file.getAbsolutePath());
            }
            return result;
        } catch (Exception e) {
            logger.error("删除文件异常: {}, 文件: {}", 
                    e.getMessage(), file.getAbsolutePath(), e);
            return false;
        }
    }
}